// +----------------------------------------------------------------------
// | 用户信息管理工具
// +----------------------------------------------------------------------
// | 统一管理用户信息的获取、缓存和更新
// | 与 Store 协同工作，Store 负责状态管理，userManager 负责数据获取和工具方法
// +----------------------------------------------------------------------

import { getUserInfo as getUserInfoAPI } from '../api/user.js';
import { USER_INFO } from '../config/cache.js';
import store from '../store/index.js';

/**
 * 用户信息管理类
 * 与 Vuex 风格的 Store 协同工作
 * 
 * 缓存策略：
 * 1. 登录成功后 - 强制刷新
 * 2. 数据更新后 - 强制刷新（用户信息、企业信息等）
 * 3. 其他情况 - 优先使用缓存
 */
class UserManager {
  constructor() {
    this.loading = false;
    this.listeners = []; // 数据变化监听器
    this.lastFetchTime = 0; // 最后获取时间
    this.cacheValidDuration = 30 * 60 * 1000; // 缓存有效期：30分钟（可选的二次验证）
  }

  /**
   * 从缓存获取用户信息
   * 优先从 Store 获取，Store 为空则从本地存储获取
   * @returns {Object|null}
   */
  getUserInfoFromCache() {
    try {
      // 优先从 Store 获取
      const storeUserInfo = store.state.app?.userInfo;
      if (storeUserInfo && Object.keys(storeUserInfo).length > 0) {
        return storeUserInfo;
      }
      
      // Store 为空，从本地存储获取
      const userInfo = wx.getStorageSync(USER_INFO);
      if (userInfo) {
        // 同步到 Store
        store.commit('app/UPDATE_USERINFO', userInfo);
        return userInfo;
      }
      return null;
    } catch (error) {
      console.error('获取缓存用户信息失败:', error);
      return null;
    }
  }

  /**
   * 保存用户信息到缓存
   * 同时更新 Store 和本地存储
   * @param {Object} userInfo 
   */
  saveUserInfoToCache(userInfo) {
    try {
      // 更新本地存储
      wx.setStorageSync(USER_INFO, userInfo);
      
      // 更新 Store
      store.commit('app/UPDATE_USERINFO', userInfo);
      
      // 通知监听器
      this.notifyListeners(userInfo);
    } catch (error) {
      console.error('保存用户信息到缓存失败:', error);
    }
  }

  /**
   * 清除用户信息缓存
   * 同时清除 Store 和本地存储
   */
  clearUserInfoCache() {
    try {
      // 清除本地存储
      wx.removeStorageSync(USER_INFO);
      
      // 清除 Store
      store.commit('app/UPDATE_USERINFO', {});
      
      // 通知监听器
      this.notifyListeners(null);
    } catch (error) {
      console.error('清除用户信息缓存失败:', error);
    }
  }

  /**
   * 从服务器获取最新用户信息并更新缓存
   * 
   * 调用时机：
   * 1. 登录成功后（必须调用）
   * 2. 用户信息修改后（头像、昵称、手机号等）
   * 3. 企业信息创建/更新后
   * 4. 缓存不存在时（自动调用）
   * 
   * @param {Boolean} showLoading 是否显示加载提示
   * @returns {Promise<Object>}
   */
  async fetchAndUpdateUserInfo(showLoading = false) {
    // 防止重复请求
    if (this.loading) {
      console.log('[userManager] 正在获取用户信息，请稍候...');
      // 等待当前请求完成
      await new Promise(resolve => setTimeout(resolve, 100));
      return this.getUserInfoFromCache();
    }

    try {
      this.loading = true;

      if (showLoading) {
        wx.showLoading({ title: '加载中...' });
      }

      console.log('[userManager] 开始请求 /api/user 接口');
      const res = await getUserInfoAPI();

      if (showLoading) {
        wx.hideLoading();
      }

      this.loading = false;

      if (res.status === 200 && res.data) {
        // 保存到缓存
        this.saveUserInfoToCache(res.data);
        
        // 记录获取时间
        this.lastFetchTime = Date.now();
        
        console.log('[userManager] API 请求成功，已更新缓存');
        return res.data;
      } else {
        throw new Error(res.msg || '获取用户信息失败');
      }
    } catch (error) {
      this.loading = false;

      if (showLoading) {
        wx.hideLoading();
      }

      console.error('[userManager] 获取用户信息失败:', error);

      // 失败时返回缓存数据
      const cachedData = this.getUserInfoFromCache();
      if (cachedData) {
        console.log('[userManager] API 请求失败，使用缓存数据');
        return cachedData;
      }

      throw error;
    }
  }
  
  /**
   * 在登录成功后调用
   * 强制刷新用户信息
   */
  async refreshAfterLogin() {
    console.log('[userManager] 登录成功，刷新用户信息');
    return await this.fetchAndUpdateUserInfo(true);
  }
  
  /**
   * 在数据更新后调用
   * 强制刷新用户信息（用户信息、企业信息等更新后）
   * @param {String} action 操作类型（用于日志）
   */
  async refreshAfterUpdate(action = '数据更新') {
    console.log(`[userManager] ${action}成功，刷新用户信息`);
    return await this.fetchAndUpdateUserInfo(false);
  }

  /**
   * 获取用户信息（优先从缓存，缓存不存在则从服务器获取）
   * 
   * 缓存策略：
   * - 默认优先使用缓存（即使过期也返回，除非强制刷新）
   * - 只在以下情况请求 API：
   *   1. forceRefresh = true（登录后、数据更新后）
   *   2. 缓存完全不存在
   * 
   * @param {Boolean} forceRefresh 是否强制刷新（登录后、更新后使用）
   * @param {Boolean} showLoading 是否显示加载提示
   * @returns {Promise<Object>}
   */
  async getUserInfo(forceRefresh = false, showLoading = false) {
    const cachedData = this.getUserInfoFromCache();
    
    // 策略1：如果有缓存且不强制刷新，直接返回缓存
    if (cachedData && !forceRefresh) {
      console.log('[userManager] 使用缓存数据，无需请求 API');
      return cachedData;
    }
    
    // 策略2：缓存不存在或强制刷新，从服务器获取
    if (forceRefresh) {
      console.log('[userManager] 强制刷新，请求 API');
    } else {
      console.log('[userManager] 缓存不存在，请求 API');
    }
    
    return await this.fetchAndUpdateUserInfo(showLoading);
  }

  /**
   * 获取企业信息（从用户信息中提取）
   * @returns {Object|null}
   */
  getEnterpriseInfo() {
    const userInfo = this.getUserInfoFromCache();
    if (userInfo && userInfo.enterprise) {
      return userInfo.enterprise;
    }
    return null;
  }

  /**
   * 检查用户是否有企业
   * @returns {Boolean}
   */
  hasEnterprise() {
    const enterprise = this.getEnterpriseInfo();
    return !!(enterprise && enterprise.id);
  }

  /**
   * 更新用户信息的某个字段
   * @param {String} key 
   * @param {Any} value 
   */
  updateUserInfoField(key, value) {
    const userInfo = this.getUserInfoFromCache();
    if (userInfo) {
      userInfo[key] = value;
      this.saveUserInfoToCache(userInfo);
    }
  }

  /**
   * 添加数据变化监听器
   * @param {Function} listener 
   */
  addListener(listener) {
    if (typeof listener === 'function') {
      this.listeners.push(listener);
    }
  }

  /**
   * 移除数据变化监听器
   * @param {Function} listener 
   */
  removeListener(listener) {
    const index = this.listeners.indexOf(listener);
    if (index > -1) {
      this.listeners.splice(index, 1);
    }
  }

  /**
   * 通知所有监听器
   * @param {Object} userInfo 
   */
  notifyListeners(userInfo) {
    this.listeners.forEach(listener => {
      try {
        listener(userInfo);
      } catch (error) {
        console.error('监听器执行失败:', error);
      }
    });
  }

  /**
   * 格式化手机号（脱敏显示）
   * @param {String} phone 
   * @returns {String}
   */
  formatPhone(phone) {
    if (!phone || phone.length !== 11) {
      return phone || '';
    }
    return phone.substring(0, 3) + '****' + phone.substring(7);
  }

  /**
   * 获取用户显示名称
   * @returns {String}
   */
  getUserDisplayName() {
    const userInfo = this.getUserInfoFromCache();
    if (userInfo) {
      return userInfo.real_name || userInfo.nickname || '用户';
    }
    return '用户';
  }

  /**
   * 获取用户头像
   * @returns {String}
   */
  getUserAvatar() {
    const userInfo = this.getUserInfoFromCache();
    return userInfo?.avatar || '';
  }

  /**
   * 获取用户头像或首字母
   * 如果有头像返回头像URL，没有则返回姓名的第一个字
   * @returns {Object} { type: 'image' | 'text', value: string }
   */
  getUserAvatarOrInitial() {
    const userInfo = this.getUserInfoFromCache();
    
    // 如果有头像URL，返回图片类型
    if (userInfo?.avatar) {
      return {
        type: 'image',
        value: userInfo.avatar
      };
    }
    
    // 没有头像，取姓名的第一个字
    const name = userInfo?.real_name || userInfo?.nickname || '用户';
    const initial = name.substring(0, 1);
    
    return {
      type: 'text',
      value: initial
    };
  }

  /**
   * 获取用户显示的首字母（用于默认头像）
   * @returns {String}
   */
  getUserInitial() {
    const userInfo = this.getUserInfoFromCache();
    const name = userInfo?.real_name || userInfo?.nickname || '用户';
    return name.substring(0, 1);
  }

  /**
   * 获取用户手机号
   * @param {Boolean} masked 是否脱敏
   * @returns {String}
   */
  getUserPhone(masked = false) {
    const userInfo = this.getUserInfoFromCache();
    const phone = userInfo?.phone || '';
    return masked ? this.formatPhone(phone) : phone;
  }

  /**
   * 检查用户是否为付费会员（vip_status === 3）
   * @returns {Boolean}
   */
  isPaidMember() {
    const userInfo = this.getUserInfoFromCache();
    return !!(userInfo && userInfo.vip_status === 3);
  }

  /**
   * 获取用户会员状态
   * @returns {Number|null} vip_status 值
   */
  getVipStatus() {
    const userInfo = this.getUserInfoFromCache();
    return userInfo?.vip_status || null;
  }

  /**
   * 检查用户是否已开通会员（包括免费和付费）
   * @returns {Boolean}
   */
  isMember() {
    const userInfo = this.getUserInfoFromCache();
    return !!(userInfo && userInfo.vip_status && userInfo.vip_status > 0);
  }

  /**
   * 获取用户ID
   * @returns {String|null}
   */
  getUserId() {
    const userInfo = this.getUserInfoFromCache();
    return userInfo?.uid || null;
  }

  /**
   * 密文显示公司名称（只显示第一个字和最后一个字，中间用*）
   * @param {String} companyName 
   * @returns {String}
   */
  maskCompanyName(companyName) {
    if (!companyName || companyName.length <= 1) {
      return companyName || '';
    }
    if (companyName.length === 2) {
      return companyName.charAt(0) + '*';
    }
    return companyName.charAt(0) + '*'.repeat(companyName.length - 2) + companyName.charAt(companyName.length - 1);
  }

  /**
   * 密文显示联系人姓名（只显示第一个字和最后一个字，中间用*）
   * @param {String} name 
   * @returns {String}
   */
  maskContactName(name) {
    if (!name || name.length <= 1) {
      return name || '';
    }
    if (name.length === 2) {
      return name.charAt(0) + '*';
    }
    return name.charAt(0) + '*'.repeat(name.length - 2) + name.charAt(name.length - 1);
  }

  /**
   * 密文显示手机号（显示前3位和后1位）
   * @param {String} phone 
   * @returns {String}
   */
  maskPhone(phone) {
    if (!phone || phone.length !== 11) {
      return phone || '';
    }
    return phone.substring(0, 3) + '****' + phone.substring(10);
  }

  /**
   * 密文显示地址（只显示省份和城市，区县用*代替）
   * @param {String} province 省份
   * @param {String} city 城市
   * @param {String} district 区县
   * @returns {String}
   */
  maskAddress(province, city, district) {
    if (!province && !city) {
      return '';
    }
    
    let address = '';
    if (province) {
      address += province;
    }
    if (city) {
      address += (address ? ' ' : '') + city;
    }
    if (district) {
      address += (address ? ' ' : '') + '*';
    }
    
    return address;
  }
}

// 创建单例
const userManager = new UserManager();

export default userManager;

// 导出常用方法（便于使用）
export const getUserInfoFromCache = () => userManager.getUserInfoFromCache();
export const saveUserInfoToCache = (userInfo) => userManager.saveUserInfoToCache(userInfo);
export const fetchAndUpdateUserInfo = (showLoading) => userManager.fetchAndUpdateUserInfo(showLoading);
export const getUserInfo = (forceRefresh, showLoading) => userManager.getUserInfo(forceRefresh, showLoading);
export const refreshAfterLogin = () => userManager.refreshAfterLogin();
export const refreshAfterUpdate = (action) => userManager.refreshAfterUpdate(action);
export const getEnterpriseInfo = () => userManager.getEnterpriseInfo();
export const hasEnterprise = () => userManager.hasEnterprise();
export const getUserDisplayName = () => userManager.getUserDisplayName();
export const getUserAvatar = () => userManager.getUserAvatar();
export const getUserAvatarOrInitial = () => userManager.getUserAvatarOrInitial();
export const getUserInitial = () => userManager.getUserInitial();
export const getUserPhone = (masked) => userManager.getUserPhone(masked);
export const formatPhone = (phone) => userManager.formatPhone(phone);
export const isPaidMember = () => userManager.isPaidMember();
export const getVipStatus = () => userManager.getVipStatus();
export const isMember = () => userManager.isMember();
export const getUserId = () => userManager.getUserId();
export const maskCompanyName = (companyName) => userManager.maskCompanyName(companyName);
export const maskContactName = (name) => userManager.maskContactName(name);
export const maskPhone = (phone) => userManager.maskPhone(phone);
export const maskAddress = (province, city, district) => userManager.maskAddress(province, city, district);

